home *** CD-ROM | disk | FTP | other *** search
/ Programming Languages Suite / ProgramD2.iso / Borland / Borland C++ V5.02 / CMDENABL.PAK / CMDENAB3.CPP < prev    next >
C/C++ Source or Header  |  1997-05-06  |  5KB  |  258 lines
  1. // ---------------------------------------------------------------------------
  2. // ObjectWindows
  3. // Copyright (C) 1994, 1995 by Borland International, All Rights Reserved
  4. //
  5. //  Command-enabling sample application
  6. //  Third version implements check marks on the toggle functions.
  7. //----------------------------------------------------------------------------
  8. #include <owl/pch.h>
  9. #include <owl/applicat.h>
  10. #include <owl/framewin.h>
  11. #include "cmdenabl.h"
  12.  
  13. //
  14. // class TCmdEnableApp
  15. // ~~~~~ ~~~~~~~~~~~~~
  16. // Application object initializes TApplication, overrides InitMainWindow.
  17. class TCmdEnableApp : public TApplication {
  18.   public:
  19.     TCmdEnableApp() : TApplication() {}
  20.  
  21.   protected:
  22.     void InitMainWindow();
  23. };
  24.  
  25.  
  26. //
  27. // class TCmdEnableWindow
  28. // ~~~~~ ~~~~~~~~~~~~~~~~
  29. // Window object initializes TWindow, adds four event handlers,
  30. // adds response table for four events.
  31. //
  32. class TCmdEnableWindow : public TWindow {
  33.   public:
  34.     TCmdEnableWindow(TWindow* parent = 0);
  35.  
  36.   protected:
  37.     // Event handlers
  38.     //
  39.     void CmFileNew();
  40.     void CmFileOpen();
  41.     void CmFileSave();
  42.     void CmFileSaveAs();
  43.     void CmToggleDirty();
  44.     void CmToggleNew();
  45.     void CmShowState();
  46.  
  47.     // Command-enabling functions
  48.     //
  49.     void CeFileNew(TCommandEnabler&);
  50.     void CeFileOpen(TCommandEnabler&);
  51.     void CeFileSave(TCommandEnabler&);
  52.     void CeToggleDirty(TCommandEnabler&);
  53.     void CeToggleNew(TCommandEnabler&);
  54.  
  55.     bool IsDirty;
  56.     bool IsNewFile;
  57.  
  58.   DECLARE_RESPONSE_TABLE(TCmdEnableWindow);
  59. };
  60.  
  61.  
  62. //
  63. //
  64. //
  65. DEFINE_RESPONSE_TABLE1(TCmdEnableWindow, TWindow)
  66.   EV_COMMAND(CM_FILENEW, CmFileNew),
  67.   EV_COMMAND(CM_FILEOPEN, CmFileOpen),
  68.   EV_COMMAND(CM_FILESAVE, CmFileSave),
  69.   EV_COMMAND(CM_FILESAVEAS, CmFileSaveAs),
  70.   EV_COMMAND(CM_TOGGLEDIRTY, CmToggleDirty),
  71.   EV_COMMAND(CM_TOGGLENEW, CmToggleNew),
  72.   EV_COMMAND(CM_SHOWSTATE, CmShowState),
  73.   EV_COMMAND_ENABLE(CM_FILENEW, CeFileNew),
  74.   EV_COMMAND_ENABLE(CM_FILEOPEN, CeFileOpen),
  75.   EV_COMMAND_ENABLE(CM_FILESAVE, CeFileSave),
  76.   EV_COMMAND_ENABLE(CM_TOGGLEDIRTY, CeToggleDirty),
  77.   EV_COMMAND_ENABLE(CM_TOGGLENEW, CeToggleNew),
  78. END_RESPONSE_TABLE;
  79.  
  80. //
  81. // TCmdEnableApp::InitMainWindow
  82. //
  83. void
  84. TCmdEnableApp::InitMainWindow()
  85. {
  86.   // Construct the frame window
  87.   //
  88.   TFrameWindow* frame = new TFrameWindow(0, "Command-enabling sample application",
  89.     new TCmdEnableWindow, true);
  90.  
  91.   // Set the main window and its menu
  92.   //
  93.   SetMainWindow(frame);
  94.   GetMainWindow()->AssignMenu(MN_COMMANDS);
  95. }
  96.  
  97.  
  98. //
  99. //
  100. //
  101. TCmdEnableWindow::TCmdEnableWindow(TWindow* parent)
  102. :
  103.   TWindow(parent),
  104.   IsNewFile(true),
  105.   IsDirty(false)
  106. {
  107. }
  108.  
  109.  
  110. //
  111. //
  112. //
  113. void
  114. TCmdEnableWindow::CmFileNew()
  115. {
  116.   IsDirty   = false;
  117.   IsNewFile = true;
  118.   MessageBox("Opened a new file.\nIsDirty=false\nIsNewFile=true",
  119.     "File action taken");
  120. }
  121.  
  122.  
  123. //
  124. //
  125. //
  126. void
  127. TCmdEnableWindow::CmFileOpen()
  128. {
  129.   IsDirty   = false;
  130.   IsNewFile = false;
  131.   MessageBox("Opened an existing file.\nIsDirty=false\nIsNewFile=false",
  132.     "File action taken");
  133. }
  134.  
  135.  
  136. //
  137. //
  138. //
  139. void
  140. TCmdEnableWindow::CmFileSave()
  141. {
  142.   IsDirty   = false;
  143.   IsNewFile = false;
  144.   MessageBox("Saved an existing file.\nIsDirty=false\nIsNewFile=false",
  145.     "File action taken");
  146. }
  147.  
  148.  
  149. //
  150. //
  151. //
  152. void
  153. TCmdEnableWindow::CmFileSaveAs()
  154. {
  155.   IsDirty   = false;
  156.   IsNewFile = false;
  157.   MessageBox("Saved a file under a new name.\nIsDirty=false\nIsNewFile=false",
  158.     "File action taken");
  159. }
  160.  
  161.  
  162. //
  163. //
  164. //
  165. void
  166. TCmdEnableWindow::CmToggleDirty()
  167. {
  168.   IsDirty=!IsDirty;
  169. }
  170.  
  171.  
  172. //
  173. //
  174. //
  175. void
  176. TCmdEnableWindow::CmToggleNew()
  177. {
  178.   IsNewFile=!IsNewFile;
  179. }
  180.  
  181.  
  182. //
  183. //
  184. //
  185. void
  186. TCmdEnableWindow::CmShowState()
  187. {
  188.   string str(IsDirty ? "IsDirty = true\n" : "IsDirty = false\n");
  189.   str += (IsNewFile ? "IsNewFile = true" : "IsNewFile = false");
  190.   MessageBox(str.c_str(), "Current state");
  191. }
  192.  
  193.  
  194. //
  195. //
  196. //
  197. void
  198. TCmdEnableWindow::CeFileNew(TCommandEnabler& ce)
  199. {
  200.   // Enable CmFileNew if not dirty
  201.   //
  202.   ce.Enable(!IsDirty);
  203. }
  204.  
  205.  
  206. //
  207. //
  208. //
  209. void
  210. TCmdEnableWindow::CeFileOpen(TCommandEnabler& ce)
  211. {
  212.   // Enable CmFileOpen if not dirty
  213.   //
  214.   ce.Enable(!IsDirty);
  215. }
  216.  
  217.  
  218. //
  219. //
  220. //
  221. void
  222. TCmdEnableWindow::CeFileSave(TCommandEnabler& ce)
  223. {
  224.   // Enable CmFileSave if not new file and is dirty.
  225.   //
  226.   ce.Enable(!IsNewFile && IsDirty);
  227. }
  228.  
  229.  
  230. //
  231. //
  232. //
  233. void
  234. TCmdEnableWindow::CeToggleDirty(TCommandEnabler& ce)
  235. {
  236.   ce.SetCheck(IsDirty ? TCommandEnabler::Checked : TCommandEnabler::Unchecked);
  237. }
  238.  
  239.  
  240. //
  241. //
  242. //
  243. void
  244. TCmdEnableWindow::CeToggleNew(TCommandEnabler& ce)
  245. {
  246.   ce.SetCheck(IsNewFile ? TCommandEnabler::Checked : TCommandEnabler::Unchecked);
  247. }
  248.  
  249. //
  250. // Put the OwlMain here just to get it out of the way
  251. //
  252. int
  253. OwlMain(int /*argc*/, char* /*argv*/ [])
  254. {
  255.   return TCmdEnableApp().Run();
  256. }
  257.  
  258.